module key_table #(
    parameter SM2_KEY_NUM = 5,    // 不得小于2
    parameter SM4_KEY_NUM = 5,    // 不得小于2
    parameter MAX_KEY_NUM = (SM2_KEY_NUM > SM4_KEY_NUM) ? SM2_KEY_NUM : SM4_KEY_NUM,
    parameter KEY_INDEX_WIDTH = $clog2(MAX_KEY_NUM)
)(
    input               clk,
    input               rst_n,
    input   [1:0]       mode,         // 00:读, 01:写, 10:删除, 11:释放权限
    input   [1:0]       key_type,     // 00=SM2, 01=SM4
    input   [KEY_INDEX_WIDTH-1:0] key_index, // 密钥索引
    input   [63:0]      pin,          // 访问PIN码
    input   [255:0]     key_1_in,     // 写入密钥值1（SM2公钥X/SM4密钥）
    input   [255:0]     key_2_in,     // 写入密钥值2（SM2公钥Y）
    input   [255:0]     key_3_in,     // 写入密钥值3（SM2私钥）
    input               in_valid,     // 写入/读/清除/释放有效（脉冲信号）

    output  reg [255:0] key_1,        // 读出密钥1（SM2公钥X/SM4密钥[低128]）
    output  reg [255:0] key_2,        // 读出密钥2（SM2公钥Y）
    output  reg [255:0] key_3,        // 读出密钥3（SM2私钥）
    output  reg         key_ready,    // 密钥输出有效
    output  reg [1:0]   state         // 00=成功, 01=PIN错误, 10=索引无效, 11=写入位置已存在密钥
);

    // 存储结构
    reg [255:0] sm2_key_x   [0:SM2_KEY_NUM-1];
    reg [255:0] sm2_key_y   [0:SM2_KEY_NUM-1];
    reg [255:0] sm2_key_d   [0:SM2_KEY_NUM-1]; // SM2私钥
    reg [63:0]  sm2_pin     [0:SM2_KEY_NUM-1];
    reg         sm2_valid   [0:SM2_KEY_NUM-1];

    reg [127:0] sm4_key     [0:SM4_KEY_NUM-1];
    reg [63:0]  sm4_pin     [0:SM4_KEY_NUM-1];
    reg         sm4_valid   [0:SM4_KEY_NUM-1];

    integer i;

    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            // 复位清空所有密钥和标志
            for (i = 0; i < SM2_KEY_NUM; i = i + 1) begin
                sm2_key_x[i] <= 0;
                sm2_key_y[i] <= 0;
                sm2_key_d[i] <= 0;
                sm2_pin[i]   <= 0;
                sm2_valid[i] <= 0;
            end
            for (i = 0; i < SM4_KEY_NUM; i = i + 1) begin
                sm4_key[i]   <= 0;
                sm4_pin[i]   <= 0;
                sm4_valid[i] <= 0;
            end
            key_1     <= 0;
            key_2     <= 0;
            key_3     <= 0;
            key_ready <= 0;
            state     <= 0;
        end else begin
            // 每周期默认清零key_ready
            key_ready <= 1'b0;

            // 只在 in_valid 上升沿执行
            if (in_valid) begin
                // mode=11: 释放权限，清零所有输出
                if (mode == 2'b11) begin
                    key_1     <= 0;
                    key_2     <= 0;
                    key_3     <= 0;
                    key_ready <= 1'b1;
                    state     <= 2'b00; // 也可设成00或10，看你需求
                end
                // 删除
                else if (mode == 2'b10) begin
                    case (key_type)
                        2'b00: begin // SM2
                            if (key_index >= SM2_KEY_NUM || !sm2_valid[key_index]) begin
                                state <= 2'b10; // 索引无效
                            end else if (pin != sm2_pin[key_index]) begin
                                state <= 2'b01; // PIN码错误
                            end else begin
                                sm2_key_x[key_index] <= 0;
                                sm2_key_y[key_index] <= 0;
                                sm2_key_d[key_index] <= 0;
                                sm2_pin[key_index]   <= 0;
                                sm2_valid[key_index] <= 0;
                                state <= 2'b00; // 成功
                            end
                        end
                        2'b01: begin // SM4
                            if (key_index >= SM4_KEY_NUM || !sm4_valid[key_index]) begin
                                state <= 2'b10; // 索引无效
                            end else if (pin != sm4_pin[key_index]) begin
                                state <= 2'b01; // PIN码错误
                            end else begin
                                sm4_key[key_index]   <= 0;
                                sm4_pin[key_index]   <= 0;
                                sm4_valid[key_index] <= 0;
                                state <= 2'b00; // 成功
                            end
                        end
                        default: begin
                            state <= 2'b10; // 不支持的类型
                        end
                    endcase
                    key_ready <= 1'b1;
                end
                // 写
                else if (mode == 2'b01) begin
                    if (key_type == 2'b00) begin // SM2
                        if (key_index >= SM2_KEY_NUM) begin
                            state <= 2'b10; // 索引无效
                        end else if (sm2_valid[key_index]) begin
                            state <= 2'b11; // 已存在密钥
                        end else begin
                            sm2_key_x[key_index] <= key_1_in;
                            sm2_key_y[key_index] <= key_2_in;
                            sm2_key_d[key_index] <= key_3_in;
                            sm2_pin[key_index]   <= pin;
                            sm2_valid[key_index] <= 1'b1;
                            state <= 2'b00; // 写入成功
                        end
                    end else if (key_type == 2'b01) begin // SM4
                        if (key_index >= SM4_KEY_NUM) begin
                            state <= 2'b10; // 索引无效
                        end else if (sm4_valid[key_index]) begin
                            state <= 2'b11; // 已存在密钥
                        end else begin
                            sm4_key[key_index]   <= key_1_in[127:0];
                            sm4_pin[key_index]   <= pin;
                            sm4_valid[key_index] <= 1'b1;
                            state <= 2'b00; // 写入成功
                        end
                    end else begin
                        state <= 2'b10; // 不支持的类型
                    end
                    key_ready <= 1'b1;
                end
                // 读
                else if (mode == 2'b00) begin
                    case (key_type)
                        2'b00: begin // SM2
                            if (key_index >= SM2_KEY_NUM || !sm2_valid[key_index]) begin
                                state <= 2'b10; // 索引无效
                                key_1 <= 0;
                                key_2 <= 0;
                                key_3 <= 0;
                            end else if (pin != sm2_pin[key_index]) begin
                                state <= 2'b01; // PIN码错误
                                key_1 <= 0;
                                key_2 <= 0;
                                key_3 <= 0;
                            end else begin
                                key_1     <= sm2_key_x[key_index];
                                key_2     <= sm2_key_y[key_index];
                                key_3     <= sm2_key_d[key_index];
                                state     <= 2'b00; // 成功
                            end
                            key_ready <= 1'b1;
                        end
                        2'b01: begin // SM4
                            if (key_index >= SM4_KEY_NUM || !sm4_valid[key_index]) begin
                                state <= 2'b10; // 索引无效
                                key_1 <= 0;
                                key_2 <= 0;
                                key_3 <= 0;
                            end else if (pin != sm4_pin[key_index]) begin
                                state <= 2'b01; // PIN码错误
                                key_1 <= 0;
                                key_2 <= 0;
                                key_3 <= 0;
                            end else begin
                                key_1     <= {128'b0, sm4_key[key_index]};
                                key_2     <= 0;
                                key_3     <= 0;
                                state     <= 2'b00; // 成功
                            end
                            key_ready <= 1'b1;
                        end
                        default: begin
                            state <= 2'b10; // 不支持的类型
                            key_1 <= 0;
                            key_2 <= 0;
                            key_3 <= 0;
                            key_ready <= 1'b1;
                        end
                    endcase
                end
                else begin
                    state <= 2'b10; // 不支持的类型
                end
            end
        end
    end

endmodule